package com.duubee.btframe.utils;

import com.alibaba.fastjson.JSONArray;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;

@SuppressWarnings(value = "all")
public class BtStringUtil {

    /**
     * 空字符串
     */
    public static final String empty = "";

    /**
     * Object对象转为String (如果Object为空则返回null)
     *
     * @param obj
     * @return
     */
    public static String toString(Object obj) {
        if (obj == null) {
            return null;
        }
        return obj.toString();
    }

    /**
     * 判断字符串是否为null或为空
     *
     * @param str
     * @return
     */
    public static boolean isEmpty(String str) {
        return str == null || str.isEmpty();
    }

    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }


    /**
     * 分割字符串
     *
     * @param str      预分割的字符串
     * @param splitStr 分割字符
     * @return
     */
    public static List<String> stringSplitToList(String str, String splitStr) {
        List<String> list = new ArrayList<>();
        String[] strArray = new String[]{};

        if (str.contains(splitStr)) {
            int index = 0;
            do {
                int newIndex = str.indexOf(splitStr, index);
                if (newIndex == -1) {
                    list.add(str.substring(index));
                    break;
                }
                list.add(str.substring(index, newIndex));
                index = newIndex + splitStr.length();

            } while (index != -1);
        } else {
            list.add(str);
        }

        return list;
    }

    /**
     * 分割字符串
     *
     * @param str      预分割的字符串
     * @param splitStr 分割字符
     * @return
     */
    public static String[] stringSplit(String str, String splitStr) {
        String[] strArray = new String[]{};
        return stringSplitToList(str, splitStr).toArray(strArray);
    }

    public static void main(String[] args) {
        System.out.println(getLeftStr("userName_like", "_LIKE"));
    }

    /**
     * 取左边的文本 (不区分大小写)
     *
     * @param str      内容
     * @param rightStr 右侧内容
     * @return 左边的内容
     */
    public static String getLeftStr(String str, String rightStr) {
        return getLeftStr(str, rightStr, false);
    }

    /**
     * 取右边的文本(不区分大小写)
     *
     * @param str     内容
     * @param leftStr 左侧内容
     * @return 右边的内容
     */
    public static String getRightStr(String str, String leftStr) {
        return getRightStr(str, leftStr, false);
    }

    /**
     * 取中间文本(不区分大小写)
     *
     * @param str
     * @param leftStr
     * @param rightStr
     * @return
     */
    public static String getCenterStr(String str, String leftStr, String rightStr) {
        return getCenterStr(str, leftStr, rightStr, 0, false);
    }


    /**
     * 取左边的文本 (不区分大小写)
     *
     * @param str           内容
     * @param rightStr      右侧内容
     * @param caseSensitive 是否区分大小写
     * @return 左边的内容
     */
    public static String getLeftStr(String str, String rightStr, boolean caseSensitive) {
        String result = null;
        if (!(str == null || rightStr == null || str.isEmpty() || rightStr.isEmpty() || str.length() <= rightStr.length())) {
            String str_ = str, rightStr_ = rightStr;
            if (!caseSensitive) {
                str_ = str_.toLowerCase();
                rightStr_ = rightStr_.toLowerCase();
            }
            int index = str_.indexOf(rightStr_);
            if (index != -1 && str.length() - index >= rightStr.length()) {
                result = str.substring(0, index);
            }
        }
        return result;
    }

    /**
     * 取右边的文本(不区分大小写)
     *
     * @param str           内容
     * @param leftStr       左侧内容
     * @param caseSensitive 是否区分大小写
     * @return 右边的内容
     */
    public static String getRightStr(String str, String leftStr, boolean caseSensitive) {

        String result = null;
        if (isNotEmpty(str) && isNotEmpty(leftStr) && str.length() > leftStr.length()) {

            String str_ = str, leftStr_ = leftStr;
            if (!caseSensitive) {
                str_ = str_.toLowerCase();
                leftStr_ = leftStr_.toLowerCase();
            }

            int index = str_.lastIndexOf(leftStr_);
            if (index != -1) {
                result = str.substring(index + leftStr.length());
            }
        }
        return result;
    }

    /**
     * 取中间文本
     *
     * @param str           字符串
     * @param leftStr       左侧文本
     * @param rightStr      右侧文本
     * @param caseSensitive 是否区分大小写
     * @return
     */
    public static String getCenterStr(String str, String leftStr, String rightStr, int startIndex, boolean caseSensitive) {

        String result = null;
        if (isNotEmpty(str) && isNotEmpty(leftStr) && isNotEmpty(rightStr) && str.length() >= (leftStr.length() + rightStr.length())) {

            String str_ = str, leftStr_ = leftStr, rightStr_ = rightStr;

            if (!caseSensitive) {
                str_ = str_.toLowerCase();
                leftStr_ = leftStr_.toLowerCase();
                rightStr_ = rightStr_.toLowerCase();
            }

            int index1 = str_.indexOf(leftStr_, startIndex);
            if (index1 != -1) {
                index1 += leftStr.length();
                int index2 = str_.indexOf(rightStr_, index1);
                if (index2 != -1) {
                    result = str.substring(index1, index2);
                }
            }
        }
        return result;

    }

    /**
     * 将一个字符串中的首字母转换成大写，其它的全部转换成小写
     *
     * @param str
     * @return
     */
    public static String getConvert(String str) {
        if (isEmpty(str)) {
            return str;
        }
        if (str.length() > 0) {
            String first = str.substring(0, 1);
            String after = "";
            first = first.toUpperCase();
            if (str.length() > 1) {
                after = str.substring(1).toLowerCase();
            }
            return first + after;
        }
        return str;

    }

    /**
     * 首字母大写
     *
     * @param str
     * @return
     */
    public static String captureStrToUpperCase(String str) {
        char[] cs = str.toCharArray();
        cs[0] -= 32;
        return String.valueOf(cs);
    }

    /**
     * 首字母小写
     *
     * @param str
     * @return
     */
    public static String captureStrToLowerCase(String str) {
        char[] cs = str.toCharArray();
        cs[0] += 32;
        return String.valueOf(cs);
    }

    /**
     * 处理数组或JSONArray数据
     *
     * @param str 用逗号分割的数据，或者用jsonArray存的数据都统一处理
     * @return 返回的数组不会为null   可能length会是0
     */
    public static String[] disposeArr(String str) {
        //参数不为empty才进行处理
        if (BtStringUtil.isNotEmpty(str)) {
            if (JSONArray.isValidArray(str)) {
                JSONArray jsonArray = JSONArray.parseArray(str);
                return jsonArray.toArray(new String[]{});
            } else {
                return BtStringUtil.stringSplit(str, ",");
            }
        }

        return new String[]{};
    }

    /**
     * 处理数组或JSONArray数据
     *
     * @param str 用逗号分割的数据，或者用jsonArray存的数据都统一处理
     * @return 返回的集合不会为null   可能size会是0
     */
    public static List<String> disposeArrOrToList(String str) {
        String[] result = BtStringUtil.disposeArr(str);
        if (result != null && result.length > 0) {
            return Arrays.asList(result);
        }
        return new ArrayList<>();
    }

    /**
     * 处理数组或JSONArray数据
     *
     * @param str 用逗号分割的数据，或者用jsonArray存的数据都统一处理
     * @return 返回的集合不会为null   可能size会是0
     */
    public static List<Long> disposeArrOrToLongList(String str) {
        List<Long> longList = new ArrayList<>();
        if (isEmpty(str)) {
            return longList;
        }

        disposeArrOrToList(str).forEach(id -> {
            longList.add(Long.parseLong(id));
        });

        return longList;
    }

    /**
     * 连接字符串
     *
     * @param arr     数组
     * @param joinStr 分割字符串
     * @return
     */
    public static String joinStr(String[] arr, String joinStr) {
        if (arr == null || arr.length < 1) {
            return null;
        }

        StringBuilder stringBuilder = new StringBuilder();
        Arrays.stream(arr).forEach(temp -> {
            stringBuilder.append(temp);
            if (BtStringUtil.isNotEmpty(joinStr)) {
                stringBuilder.append(joinStr);
            }
        });

        if (stringBuilder.length() > joinStr.length() && BtStringUtil.isNotEmpty(joinStr)) {
            stringBuilder.delete(stringBuilder.length() - joinStr.length(), stringBuilder.length());
        }

        return stringBuilder.toString();
    }

    /**
     * 连接字符创
     *
     * @param arr 数组
     * @return
     */
    public static String joinStr(String[] arr) {
        return joinStr(arr);
    }

    /**
     * 连接字符串
     *
     * @param arr     数组
     * @param joinStr 分割字符串
     * @return
     */
    public static String joinStr(Integer[] arr, String joinStr) {
        if (arr == null || arr.length < 1) {
            return null;
        }

        StringBuilder stringBuilder = new StringBuilder();
        Arrays.stream(arr).forEach(temp -> {
            stringBuilder.append(temp);
            stringBuilder.append(joinStr);
        });

        if (stringBuilder.length() > 1) {
            stringBuilder.delete(stringBuilder.length() - 1, stringBuilder.length());
        }

        return stringBuilder.toString();
    }

    /**
     * 连接字符串
     *
     * @param arr 数组
     * @return
     */
    public static String joinStr(Integer[] arr) {
        return joinStr(arr, null);
    }

    /**
     * 连接字符串
     *
     * @param arr     数组
     * @param joinStr 分割字符串
     * @return
     */
    public static String joinStr(List<String> arr, String joinStr) {
        if (arr == null || arr.size() < 1) {
            return null;
        }
        return joinStr(arr.toArray(new String[]{}), joinStr);
    }

    /**
     * 连接字符串
     *
     * @param arr 数组
     * @return
     */
    public static String joinStr(List<String> arr) {
        return joinStr(arr, null);
    }

    /**
     * 连接字符串
     *
     * @param arr     数组
     * @param joinStr 分割字符串
     * @return
     */
    public static String joinInteger(List<Integer> arr, String joinStr) {
        if (arr == null || arr.size() < 1) {
            return null;
        }
        return joinStr(arr.toArray(new Integer[]{}), joinStr);
    }

    /**
     * 连接字符串
     *
     * @param arr 数组
     * @return
     */
    public static String joinInteger(List<Integer> arr) {
        return joinInteger(arr, null);
    }

    /**
     * 左边是否包含(区分大小写)
     *
     * @param string   源字符串
     * @param checkStr 校验字符串
     * @return
     */
    public static boolean containsLeft(String string, String checkStr) {
        if (BtStringUtil.isNotEmpty(string) && BtStringUtil.isNotEmpty(checkStr) && checkStr.length() <= string.length()) {
            return string.indexOf(checkStr) == 0;
        }
        return false;
    }

    /**
     * 左边是否包含(区分大小写)--批量 (如果其中一个包含就返回true)
     *
     * @param string    源字符串
     * @param checkStrs 校验字符串
     * @return
     */
    public static boolean containsLeft(String string, String... checkStrs) {
        if (BtStringUtil.isNotEmpty(string) && checkStrs != null && checkStrs.length > 0) {
            for (String cs : checkStrs) {
                if (BtStringUtil.containsLeft(string, cs)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 右边是否包含(区分大小写)
     *
     * @param string   源字符串
     * @param checkStr 校验字符串
     * @return
     */
    public static boolean containsRight(String string, String checkStr) {
        if (BtStringUtil.isNotEmpty(string) && BtStringUtil.isNotEmpty(checkStr) && checkStr.length() <= string.length()) {
            return string.substring(string.length() - checkStr.length()).equals(checkStr);
        }
        return false;
    }

    /**
     * 判断是否为整数
     *
     * @param str 传入的字符串
     * @return 是整数返回true, 否则返回false
     */
    public static boolean isNumeric(String str) {
        if (BtStringUtil.isNotEmpty(str)) {
            Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
            return pattern.matcher(str).matches();
        }
        return false;
    }

    /**
     * 字符串分割 ，两个字符串
     *
     * @param str
     * @return
     */
    public static List<String> stringSplitTowChar(String str) {
        List<String> stringList = new ArrayList<>();
        if (isNotEmpty(str)) {
            for (int i = 0; i < str.length(); i += 2) {
                int end = ((i + 2 > str.length() - 1) ? str.length() : (i + 2));
                stringList.add(str.substring(i, end));
            }
        }
        return stringList;
    }

    /**
     * 分割字符串 (每个X字符插入分割符)
     * @param str 字符串
     * @param split 分割符
     * @param length 长度
     * @return 结果
     */
    public static String getSplitString(String str, String split, int length) {
        int len = str.length();
        StringBuilder temp = new StringBuilder();
        for (int i = 0; i < len; i++) {
            if (i % length == 0 && i > 0) {
                temp.append(split);
            }
            temp.append(str.charAt(i));
        }
        String[] attrs = temp.toString().split(split);
        StringBuilder finalMachineCode = new StringBuilder();
        for (String attr : attrs) {
            if (attr.length() == length) {
                finalMachineCode.append(attr).append(split);
            }
        }
        String result = finalMachineCode.toString().substring(0,
                finalMachineCode.toString().length() - 1);
        return result;
    }

}
